import { useState } from "react"
import { useToast } from "@/hooks/use-toast"

export function useTableView() {
  const { toast } = useToast()
  
  // 表格查看弹窗状态
  const [tableViewOpen, setTableViewOpen] = useState(false)
  const [tableViewData, setTableViewData] = useState<any>(null)
  const [tableViewLoading, setTableViewLoading] = useState(false)
  const [tableViewTitle, setTableViewTitle] = useState('')
  const [filteredTableData, setFilteredTableData] = useState<any>(null)
  const [selectedFilter, setSelectedFilter] = useState<string>('all')

  // 解析工作表内的子表
  const parseSubTables = (sheet: any) => {
    const subTables: Array<{name: string, startRow: number, endRow: number, data: any[]}> = [];
    
    // 首先检查headers中是否有表标题
    if (sheet.headers && sheet.headers[0] && typeof sheet.headers[0] === 'string' && sheet.headers[0].includes('表 C.')) {
      const tableName = sheet.headers[0].trim();
      subTables.push({
        name: tableName,
        startRow: 0,
        endRow: sheet.rows.length - 1,
        data: sheet.rows
      });
    }
    
    // 然后在rows中查找其他子表
    for (let i = 0; i < sheet.rows.length; i++) {
      const row = sheet.rows[i];
      if (row && row[0] && typeof row[0] === 'string' && row[0].includes('表 C.')) {
        // 找到子表标题
        const tableName = row[0].trim();
        const startRow = i;
        
        // 找到下一个子表的开始位置或工作表结束
        let endRow = sheet.rows.length - 1;
        for (let j = i + 1; j < sheet.rows.length; j++) {
          const nextRow = sheet.rows[j];
          if (nextRow && nextRow[0] && typeof nextRow[0] === 'string' && nextRow[0].includes('表 C.')) {
            endRow = j - 1;
            break;
          }
        }
        
        // 提取子表数据
        const tableData = sheet.rows.slice(startRow, endRow + 1);
        subTables.push({
          name: tableName,
          startRow,
          endRow,
          data: tableData
        });
      }
    }
    
    return subTables;
  };

  // 过滤表格数据的函数
  const filterTableData = (filterType: string) => {
    if (!tableViewData) return;

    setSelectedFilter(filterType);

    if (filterType === 'all') {
      setFilteredTableData(tableViewData);
      return;
    }

    // 查找数据来源列的索引
    let dataSourceColumnIndex = -1;
    const headers = tableViewData.headers || [];

    // 查找包含"数据来源"、"来源"等关键词的列
    for (let i = 0; i < headers.length; i++) {
      const header = headers[i]?.toString().toLowerCase() || '';
      if (header.includes('数据来源') || header.includes('来源') || header.includes('source')) {
        dataSourceColumnIndex = i;
        break;
      }
    }

    // 如果没有找到数据来源列，尝试查找最后几列中可能包含P、E、C、R的列
    if (dataSourceColumnIndex === -1) {
      for (let i = Math.max(0, headers.length - 3); i < headers.length; i++) {
        const header = headers[i]?.toString() || '';
        if (header.length <= 3 && (header.includes('P') || header.includes('E') || header.includes('C') || header.includes('R'))) {
          dataSourceColumnIndex = i;
          break;
        }
      }
    }

    console.log('数据来源列索引:', dataSourceColumnIndex, '表头:', headers);

    // 根据数据来源过滤数据
    const filtered = {
      ...tableViewData,
      rows: tableViewData.rows.filter((row: any[]) => {
        if (dataSourceColumnIndex === -1) {
          // 如果没有找到数据来源列，在所有列中搜索
          const allCells = row.join(' ').toUpperCase();
          return allCells.includes(filterType);
        } else {
          // 在指定的数据来源列中搜索
          const dataSourceCell = row[dataSourceColumnIndex]?.toString().toUpperCase() || '';
          return dataSourceCell.includes(filterType);
        }
      })
    };

    console.log('过滤结果:', filtered.rows.length, '条数据');
    setFilteredTableData(filtered);
  };

  // 加载并显示表格数据的函数
  const loadAndShowTableData = async (classificationCode: string, tableName: string, type: 'naming' | 'location' | 'basic') => {
    console.log('点击表格链接:', { classificationCode, tableName, type });
    setTableViewLoading(true);
    setTableViewOpen(true);
    setTableViewTitle(`${tableName} - ${type === 'naming' ? '对象命名' : type === 'location' ? '位置信息' : '基础参数'}表`);

    try {
      // 加载分类表Excel文件
      const filename = encodeURIComponent('06-06/0606-石楼油库实体对象分类表.xlsx');
      const response = await fetch(`/api/excel?filename=${filename}`);
      if (!response.ok) {
        throw new Error('加载Excel文件失败');
      }
      const excelData = await response.json();

      // 查找对应的表格数据
      let targetTable = null;

      // 从表名中提取C开头的分类码，如果没有则使用传入的分类码
      let searchCode = classificationCode;
      const cCodeMatch = tableName.match(/表\s*(C\.\d+)/);
      if (cCodeMatch) {
        searchCode = cCodeMatch[1];
      }

      console.log('搜索分类码:', searchCode);

      // 在所有工作表中查找包含指定分类码的表
      for (const sheet of excelData.sheets) {
        if (sheet.sheetName.startsWith('C')) {
          // 解析工作表内的子表
          const subTables = parseSubTables(sheet);

          for (const subTable of subTables) {
            // 检查子表名称是否包含搜索的分类码
            if (subTable.name.includes(searchCode)) {
              // 找到实际的表头行
              let actualHeaders = [];
              let actualRows = subTable.data;

              // 查找包含"序号"、"中文名称"等关键词的行作为表头
              for (let i = 0; i < Math.min(3, subTable.data.length); i++) {
                const row = subTable.data[i];
                if (row && row[0] && typeof row[0] === 'string' &&
                    (row[0].includes('序号') || row[0].includes('中文名称') || row[0].includes('属性名称'))) {
                  actualHeaders = row;
                  actualRows = subTable.data.slice(i + 1);
                  break;
                }
              }

              // 如果没找到合适的表头，使用第一行
              if (actualHeaders.length === 0 && subTable.data.length > 0) {
                actualHeaders = subTable.data[0];
                actualRows = subTable.data.slice(1);
              }

              targetTable = {
                name: subTable.name,
                headers: actualHeaders,
                rows: actualRows.filter(row => row && row[0] && row[0] !== null && row[0] !== '')
              };
              break;
            }
          }
          if (targetTable) break;
        }
      }

      // 如果没有找到特定的表，显示第一个C开头的表作为默认
      if (!targetTable) {
        console.log('未找到特定表，显示默认表');
        for (const sheet of excelData.sheets) {
          if (sheet.sheetName.startsWith('C')) {
            const subTables = parseSubTables(sheet);
            if (subTables.length > 0) {
              const firstTable = subTables[0];

              // 找到实际的表头行
              let actualHeaders = [];
              let actualRows = firstTable.data;

              for (let i = 0; i < Math.min(3, firstTable.data.length); i++) {
                const row = firstTable.data[i];
                if (row && row[0] && typeof row[0] === 'string' &&
                    (row[0].includes('序号') || row[0].includes('中文名称') || row[0].includes('属性名称'))) {
                  actualHeaders = row;
                  actualRows = firstTable.data.slice(i + 1);
                  break;
                }
              }

              if (actualHeaders.length === 0 && firstTable.data.length > 0) {
                actualHeaders = firstTable.data[0];
                actualRows = firstTable.data.slice(1);
              }

              targetTable = {
                name: firstTable.name,
                headers: actualHeaders,
                rows: actualRows.filter(row => row && row[0] && row[0] !== null && row[0] !== '')
              };
              break;
            }
          }
        }
      }

      setTableViewData(targetTable);
      setFilteredTableData(targetTable);
      setSelectedFilter('all');
    } catch (error) {
      console.error('加载表格数据失败:', error);
      toast({
        title: "加载失败",
        description: "无法加载表格数据，请重试",
        variant: "destructive",
      });
    } finally {
      setTableViewLoading(false);
    }
  };

  return {
    tableViewOpen,
    setTableViewOpen,
    tableViewData,
    tableViewLoading,
    tableViewTitle,
    filteredTableData,
    selectedFilter,
    loadAndShowTableData,
    filterTableData,
  }
}
